package com.ysd.twocrm.service.impl;

import com.ysd.twocrm.entity.Modules;
import com.ysd.twocrm.entity.ModulesTree;
import com.ysd.twocrm.entity.Permission;
import com.ysd.twocrm.mapper.ModulesMapper;
import com.ysd.twocrm.mapper.PermissionMapper;
import com.ysd.twocrm.service.ModulesService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class MoudulesServiceImpl implements ModulesService {
    @Autowired
    private ModulesMapper modulesMapper;
    @Autowired
    private PermissionMapper permissionMapper;

    @Override
    public List<Modules> modulesUname( Integer userId) {

        return modulesMapper.modulesUname(userId);//查询用户拥有的模块
    }

    /*
     * @Description 构建树模型，判断当前的父节点是顶层对象，然后去查找当前顶层对象的子类
     * @param unames：为了调用上面的方法来查询当前用户的所有模块
     * @return java.util.List<com.ysd.twocrm.entity.Modules>
     * @author liusupeng
     * @date 2020/4/9 10:49
     */
    @Override
    public List<Modules> getTreeNode(Integer userId) {

        List<Modules> modulesAll = modulesUname(userId);//调用用户拥有的模块
        List<Modules> mlist = new ArrayList<Modules>();//创建一个存储模块的集合
        for (Modules m : modulesAll) {
            if (m.getModulesParentId() == 0) {
                mlist.add(findChildren(m, modulesAll));
            }
        }
        return mlist;
    }

    /*
     * @Description 判断当前是否是顶层对象，如果他拥有他的子类，则添加到子类里
     * @param m :模块
     * @param mlist ：当前用户所拥有的全部模块
     * @return com.ysd.twocrm.entity.Modules
     * @author liusupeng
     * @date 2020/4/9 10:42
     */
    @Override
    public Modules findChildren(Modules m, List<Modules> mlist) {
        for (Modules item : mlist) {
            if (m.getModulesId() == item.getModulesParentId()) {
                if (m.getChildren() == null) {
                    m.setChildren(new ArrayList<Modules>());
                }
                m.getChildren().add(findChildren(item, mlist));
            }
        }
        return m;
    }

    @Override
    public List<Modules> selectParentId() {
        return modulesMapper.selectParentId();//查询顶层对象
    }

    //为layui的tree结构来构造的
    @Override
    public List<ModulesTree> getTreeNodeOne() {
        List<ModulesTree> modules = modulesMapper.selectModulesList();
        List<ModulesTree> mlist=new ArrayList<>();
        for(ModulesTree m:modules){
              if(m.getParentid()==0){
                  mlist.add(findChildrentree(m,modules));
              }
        }
        return mlist;
    }


    // 转换权限
    /*
     * @Description  先查询出全部模块信息，然后查询出权限信息，因为两张表的一个字段都一样，也就是名字
     * 所以我们进行双层遍历循环来通过if判断，如果两个名字一样，则为他添加数据将权限的信息填充到模块树字段里的
     * @param
     * @return java.util.List<com.ysd.twocrm.entity.ModulesTree>
     * @author liusupeng
     * @date 2020/4/19 11:51
     */

    public List<ModulesTree> getModulesAndPermission(){

        List<ModulesTree> modulesTreeList = modulesMapper.selectModulesList();//查询全部模块
        List<Permission> permissionList = permissionMapper.selectList(null);
        for(ModulesTree mt:modulesTreeList){
            for(Permission p:permissionList){
                if(mt.getTitle().equals(p.getPermissionModule())){
                    if(mt.getPermissionList()==null){
                        mt.setPermissionList(new ArrayList<Permission>());
                    }
                     mt.getPermissionList().add(p);
                }
            }

        }
        return modulesTreeList;
    }
    /*
     * @Description 1.获取到转换过了的模块信息
     * 2. 遍历这个数组，然后进行判断，如果当前模块的父id为0则去寻找他的子类
     * @param
     * @return java.util.List<com.ysd.twocrm.entity.ModulesTree>
     * @author liusupeng
     * @date 2020/4/19 11:53
     */
public List<ModulesTree> getLayuiPermmion(){

    List<ModulesTree> modulesAndPermission = getModulesAndPermission();
    List<ModulesTree> modulesTreeList=new ArrayList<ModulesTree>();
    for(int i=0;i<modulesAndPermission.size();i++){
        ModulesTree modulesTree = modulesAndPermission.get(i);
        if(modulesTree.getParentid()==0){
            modulesTreeList.add(this.modulesTreeChildren(modulesTree,modulesAndPermission));
        }
    }
    return modulesTreeList;
}
    /*
     * @Description  首先先进行转换数据，判断如果当前遍历modules的时候的mt里面permission不为空了，也就是有数据，
     * 那么就给他转换到modulestree的实体类，并且会进行一个深层判断，如果他不为空并且他的children为空了，
     * 则将转换的数据添加到modulestreee里面
     * 接下来就是查找子类
     *   先循环遍历出modules（全部模块信息）去查询当前遍历的id和全部模块信息的父id是否一样？如果一样了，就去查找他的子类
     * @param mt 遍历modules
     * @param modules 全部信息
     * @return com.ysd.twocrm.entity.ModulesTree
     * @author liusupeng
     * @date 2020/4/19 11:53
     */
    public ModulesTree modulesTreeChildren(ModulesTree mt,List<ModulesTree> modules){

        if(mt.getPermissionList()!=null){
            for(int i=0;i<mt.getPermissionList().size();i++){
                Permission permission = mt.getPermissionList().get(i);
                   ModulesTree mtree=new ModulesTree();
                   mtree.setId(permission.getPermissionId());
                   mtree.setTitle(permission.getTitle());
                    if(mt.getChildren()==null){
                        mt.setChildren(new ArrayList<ModulesTree>());
                    }
                mt.getChildren().add(mtree);
            }
        }
        //查找子类
           for(int i=0;i<modules.size();i++){
               ModulesTree modulesTree = modules.get(i);
               if(mt.getId().equals(modulesTree.getParentid())){

                         if(mt.getChildren()==null){
                             mt.setChildren(new ArrayList<ModulesTree>());
                         }
                         mt.getChildren().add(this.modulesTreeChildren(modulesTree,modules));
               }
           }

        return mt;
    }



    //为layui的tree结构来查询子节点
    public ModulesTree findChildrentree(ModulesTree m, List<ModulesTree> mlist) {
        for (ModulesTree item : mlist) {
            if (m.getId() == item.getParentid()) {
                if (m.getChildren() == null) {
                    m.setChildren(new ArrayList<ModulesTree>());
                }
                m.getChildren().add(findChildrentree(item, mlist));
            }
        }
        return m;
    }
}
